import 'dart:async';
import 'dart:collection';

import 'package:collection/collection.dart';

// 任务优先级枚举
enum TaskPriority {
  low(0),
  medium(1),
  high(2);

  final int value;
  const TaskPriority(this.value);
}

// 任务类
class Task {
  final String id;
  final TaskPriority priority;
  final Future<void> Function() execute;
  final Completer<void> completer = Completer<void>();

  Task({
    required this.id,
    required this.priority,
    required this.execute,
  });
}

// 任务队列类
class PriorityTaskQueue {
  // 使用优先队列存储待执行任务
  final _pendingTasks = HeapPriorityQueue<Task>((a, b) =>
      b.priority.value.compareTo(a.priority.value)); // 优先级高的在前

  // 存储被中断的任务（栈结构，后进先出）
  final _interruptedTasks = Queue<Task>();

  // 当前正在执行的任务
  Task? _currentTask;

  // 是否正在执行任务
  bool get isExecuting => _currentTask != null;

  // 添加任务到队列
  Future<void> addTask(Task task) {
    _pendingTasks.add(task);
    _checkForHigherPriority();
    return task.completer.future;
  }

  // 检查是否有更高优先级的任务
  void _checkForHigherPriority() {
    if (_currentTask != null &&
        _pendingTasks.isNotEmpty &&
        _pendingTasks.first.priority.value > _currentTask!.priority.value) {
      // 中断当前任务，执行更高优先级的任务
      _interruptCurrentTask();
    } else if (!isExecuting) {
      // 没有任务在执行，开始执行下一个任务
      _executeNextTask();
    }
  }

  // 中断当前任务
  void _interruptCurrentTask() {
    if (_currentTask != null) {
      print('中断任务: ${_currentTask!.id}');
      _interruptedTasks.addLast(_currentTask!);
      _currentTask = null;
      _executeNextTask();
    }
  }

  // 执行下一个任务
  void _executeNextTask() {
    if (_pendingTasks.isEmpty) {
      // 没有待执行任务，尝试恢复被中断的任务
      _resumeInterruptedTasks();
      return;
    }

    _currentTask = _pendingTasks.removeFirst();
    print('开始执行任务: ${_currentTask!.id}, 优先级: ${_currentTask!.priority}');

    // 执行任务
    _currentTask!.execute().then((_) {
      print('完成任务: ${_currentTask!.id}');
      _currentTask!.completer.complete();
      _currentTask = null;
      _executeNextTask();
    }).catchError((error) {
      if(_currentTask!=null){
      print('任务失败: ${_currentTask!.id}, 错误: $error');
      _currentTask!.completer.completeError(error);
      _currentTask = null;
      }
      _executeNextTask();
    });
  }

  // 恢复被中断的任务
  void _resumeInterruptedTasks() {
    if (_interruptedTasks.isNotEmpty) {
      // 将中断的任务重新加入待执行队列
      final interruptedTask = _interruptedTasks.removeLast();
      _pendingTasks.add(interruptedTask);
      _executeNextTask();
    }
  }

  // 获取队列状态信息
  void printQueueStatus() {
    print('当前执行任务: ${_currentTask?.id ?? "无"}');
    print('待执行任务数: ${_pendingTasks.length}');
    print('被中断任务数: ${_interruptedTasks.length}');
  }
}

// 示例使用
void main() async {
  final taskQueue = PriorityTaskQueue();

  // 添加一个低优先级任务
  final lowPriorityTask = Task(
    id: '任务1',
    priority: TaskPriority.low,
    execute: () async {
      print('低优先级任务开始执行');
      await Future.delayed(Duration(seconds: 3));
      print('低优先级任务执行完成');
    },
  );

  // 添加一个高优先级任务（会中断低优先级任务）
  final highPriorityTask = Task(
    id: '任务2',
    priority: TaskPriority.high,
    execute: () async {
      print('高优先级任务开始执行');
      await Future.delayed(Duration(seconds: 1));
      print('高优先级任务执行完成');
    },
  );

  // 添加一个中优先级任务
  final mediumPriorityTask = Task(
    id: '任务3',
    priority: TaskPriority.medium,
    execute: () async {
      print('中优先级任务开始执行');
      await Future.delayed(Duration(seconds: 2));
      print('中优先级任务执行完成');
    },
  );

  print('添加低优先级任务');
  taskQueue.addTask(lowPriorityTask);
  await Future.delayed(Duration(seconds: 1));

  print('添加高优先级任务');
  taskQueue.addTask(highPriorityTask);
  await Future.delayed(Duration(seconds: 1));

  print('添加中优先级任务');
  taskQueue.addTask(mediumPriorityTask);

  // 等待所有任务完成
  await Future.delayed(Duration(seconds: 5));
  taskQueue.printQueueStatus();
}